perm filename APP5[AIM,DBL] blob
sn#126860 filedate 1974-10-30 generic text, type T, neo UTF8
00100 .DEVICE XGP
00200 .FONT 1 "FIX25"
00300 .FONT 2 "SIGN57"
00400 .FONT 3 "SHD40"
00500 .FONT 4 "BDI25"
00600 .FONT 5 "NGB30"
00700 .FONT 6 "NGR20"
00800 .PAGE FRAME 53 HIGH 77 WIDE
00900 .TURN ON "↓_π{"
01000 .TURN ON "\" FOR "%"
01100 .MACRO B ⊂ BEGIN VERBATIM GROUP ⊃
01200 .MACRO E ⊂ APART END ⊃
01300 .TABBREAK
01400 .COMPACT
01500 .EVERY FOOTING(\6Fourth Draft .... {DATE},page A5.{IF PAGE = 1 THEN 1 ELSE PAGE},User/PUP6 Dialogue excerpts\*)
01600 .EVERY HEADING(\3BEINGS\*,,\4Doug Lenat\*)
01700 .COUNT PAGE PRINTING "1"
01800 .NEXT PAGE
01900
02000 \2APPENDIX 5. \* \3CF .... DIALOGUE\*
02100 .B
02200
02300
02400 .E
02500
02600 Here are fragments of the dialogue which the user went through with
02700 PUP6 to generate the CF program.
02800 Keep in mind that the entire dialogue occupied half a million characters,
02900 so only 3% of it is presented here. Even these numbers are deceptively
03000 small; they assume the user never interrupts. If he does, the size of the
03100 interaction can swell
03200 by two orders of magnitude! As an example of this, a
03300 four line long patch of the dialogue, near the beginning, was re-run in
03400 a mode which allowed the user to interrupt after each BEING transferred
03500 control, and query (ask some of the thirty questions) BEINGs as they ran.
03600 The duplicated patch is set off by rows of asterisks, on page A5.2.
03700 The expanded version occupies pages A5.13 to A5.20.
03800 As usual, the user's reponses are \4ITALICIZED\*,
03900 and the author's meta-comments are in \5LARGE, BOLD type\*.
04000 Frequently, the user is asked to pick a name for a new BEING. He is
04100 presented with a set of plausible choices, from which he may deviate.
04200 This verbosity obscures the heart of the dialogue, so only the first
04300 such naming is tolerated below; the others were deleted.
04400 Names of new, specialized
04500 versions of existing BEINGs are typically suffixed
04600 by a number. The colon (:) is used like a hyphen below, for unimportant
04700 reasons.
00100 .NOFILL
00200
00300
00400
00500 ←\4ENTER(T)\*
00600
00700 USER INTERRUPT LEVEL... \40\*
00800
00900 PUP: (PUP WANTS ANY TASK)
01000
01100
01200 USER: \4(WRITE A PROGRAM WHICH DOES CONCEPT FORMATION)\*
01300
01400 PUP: (PUP IS ABOUT TO WRITE A PROGRAM TO DO (CONCEPT:FORMATION))
01500
01600
01700 PUP: ((C:F CONCEPT:FORMATION C CF) IS THE SET OF PLAUSIBLE NAMES OF
01800 (CONCEPT FORMATION) WHICH IS AN EXPANSION OF
01900 CONCEPT:FORMATION)
02000
02100 PUP: (PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED
02200 VERSION OF ( CONCEPT:FORMATION))
02300
02400 I DON'T KNOW ANY NAMES FOR ( CONCEPT:FORMATION), SO YOU'LL HAVE TO
02500 TYPE A BRAND NEW NAME IN TO ME.
02600
02700 USER: \4CF\*
02800
02900 PUP: (PUP & USER MAY REFER TO THIS NEW
03000 SPECIALIZED VERSION OF (CONCEPT:FORMATION) AS CF:1)
03100
03200 PUP: (THE NAME OF THE PROGRAM TO DO (CONCEPT:FORMATION) IS CF:1)
03300
03400 \5*************************************************************\*
03500
03600 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
03700
03800 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
03900 (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1)
04000 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
04100 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
04200
04300 NOW TYPE YOUR ANSWER: \4NO\*
04400
04500 OK, READY TO MOVE ON NOW.
04600
04700 \5*************************************************************\*
04800
04900
05000 PUP IS NOW GOING TO ENCODE THE PIECE
05100 (TEMPORARILY (PARTITION:A:DOMAIN))
05200 OF THE FUNCTION CF:1 INTO LISP. FUNCTION NAMES WILL
05300 BE QUERIED IN PREORDER, AS NEEDED.
05400
05500 DRAW A LINE FROM THE FUNCTION CALL NIL OF THE FUNCTION CF:1 TO THIS NEW
05600 PIECE OF CODE, WHICH IS ITS BODY:
05700
05800 (CF:1
05900 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
06000 (TEMPORARILY (PAD:2))))
06100
06200 (CF:1 redefined)
06300 .FILL
06400 \5 The "piece of code" is now just the META:CODE of the new BEING
06500 CF:1. Other parts have been filled in, so it is no longer defined as
06600 above. The full, long definition contains much bookkeeping but
06700 nothing of relevance to tell the user. The "function call NIL"
06800 mentioned above indicates that CF:1 is the topmost function; it is
06900 not called by any other. \*
07000 .NOFILL
07100
07200 MOVE CURSOR TO ( PAD:2 TYPE OF ( PARTITION:A:DOMAIN))
07300
07400 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
07500 (PARTITION:BY:TAKE:ELE:AND:CLASS
07600 PARTITION:BY:TAKE:CLASS:GET:ELE
07700 PARTITION:BY:TAKE:ELE:GET:CLASS)
07800 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
07900 (A .... PARTITION:BY:TAKE:ELE:AND:CLASS)
08000 (B .... PARTITION:BY:TAKE:CLASS:GET:ELE)
08100 (C .... PARTITION:BY:TAKE:ELE:GET:CLASS)
08200
08300 FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT
08400
08500 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
08600
08700 .FILL
08800 \5<TAKE involves trivial accessing or reading in;
08900 GET involves working to obtain, e.g., by searching or computing;
09000 ELE refers to a scene; CLASS refers to the model of a concept.>\*
09100 .NOFILL
09200
09300
09400 USER: \4(A C)\*
09500
09600 AT THIS POINT, I ALMOST RECOMMENDED VIRTUAL STRUCTURING, BUT DECIDED
09700 AGAINST IT. THE LIST STRUCTURE WOULD HAVE BEEN DIVIDED INTO THESE
09800 PIECES: (PARTITION:BY:TAKE:ELE:AND:CLASS:PART:OF:NIL
09900 PARTITION:BY:TAKE:ELE:GET:CLASS:PART:OF:NIL)
10000 (I GUESS THAT EACH OF THE ABOVE :NIL-S WOULD GET REPLACED BY SOMETHING
10100 LIKE ":PARTITION:LIST")
10200
10300 PUP IS NOW GOING TO ENCODE THE PIECE
10400 (REPEATEDLY (TAKE:HOLD:OF ELEMENT)
10500 (COND ((IS:OF:TYPE ELEMENT (COMMENT PARTITION:BY:TAKE:ELE:
10600 -AND:CLASS))
10700 (TAKE:HOLD:OF NAME:OF:CLASS)
10800 (MODIFY:STRUCTURE NAME:OF:CLASS))
10900 (T
11000 (GET:HOLD:OF NAME:OF:CLASS)
11100 (MODIFY:STRUCTURE NAME:OF:CLASS))))
11200
11300 OF THE FUNCTION PAD:2 INTO LISP. FUNCTION NAMES WILL
11400 BE QUERIED IN PREORDER, AS NEEDED.
11500
11600 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( TAKE:HOLD:OF)
11700 THE NAME CHOSEN IS TAKE:HOLD:OF:3
11800
11900 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( ELEMENT)
12000 THE NAME CHOSEN IS ELEMENT:4
12100
12200 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( IS:OF:TYPE)
12300 THE NAME CHOSEN IS HAS:NAME:5
12400
12500 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( ELEMENT)
12600 IS THIS THE SAME AS A ( ELEMENT) WHICH WE'VE ALREADY SEEN AND NAMED?
12700
12800 USER: \4YES\*
12900
13000 SINCE ELEMENT:4 IS THE ONLY NAME FOR ( ELEMENT),
13100 AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
13200 YOU WANT. AM I RIGHT?
13300 USER: \4YES\*
13400
13500 THE NAME CHOSEN IS ELEMENT:4
13600
13700 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( TAKE:HOLD:OF)
13800 THE NAME CHOSEN IS TAKE:HOLD:OF:6
13900
14000 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED
14100 VERSION OF ( MODIFY:STRUCTURE)
14200 THE NAME CHOSEN IS MODIFY:STRUCTURE:7
14300
14400 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED VERSION OF ( GET:HOLD:OF)
14500 THE NAME CHOSEN IS GET:HOLD:OF:8
14600
14700 PUP WANTS USER TO TYPE IN NAME FOR SPECIALIZED
14800 VERSION OF ( MODIFY:STRUCTURE)
14900 THE NAME CHOSEN IS MODIFY:STRUCTURE:9
15000
15100 \5<from now on, even this level of naming detail will be omitted.>\*
15200
15300 DRAW A LINE FROM THE FUNCTION CALL (PAD:2) OF THE FUNCTION PAD:2 TO THIS
15400 NEW PIECE OF CODE, WHICH IS ITS BODY:
15500
15600 (PAD:2
15700 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
15800 (PROG NIL
15900 LABEL:1
16000 (TAKE:HOLD:OF:3 ELEMENT:4)
16100 (COND
16200 ((HAS:NAME:5 ELEMENT:4 (COMMENT PARTITION:BY:TAKE:ELE:
16300 -AND:CLASS))
16400 (TAKE:HOLD:OF:6 NAME:OF:CLASS)
16500 (MODIFY:STRUCTURE:7 NAME:OF:CLASS))
16600 (T
16700 (GET:HOLD:OF:8 NAME:OF:CLASS)
16800 (MODIFY:STRUCTURE:9 NAME:OF:CLASS)))
16900 (GO LABEL:1)
17000 (COMMENT INFINITE LOOP IN THIS PROG))))
17100
17200 (PAD:2 redefined) \5<as a BEING>\*
17300
17400 MOVE CURSOR TO ( ELEMENT:4 TYPE OF ( ELEMENT))
17500
17600 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION
17700 DECISION: (WHAT IS AN ELEMENT)
17800 SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
17900 TYPE IN THE DEFINITION OF ELEMENT:4
18000
18100 SHOULD I DISCUSS RAMIFICATIONS? \4NO\* \5<henceforth, this will be omitted>\*
18200
18300 USER: \4(A DESCRIPTION OF A STATIC SCENE)\*
18400
18500 DRAW A LINE FROM THE FUNCTION CALL (ELEMENT:4 (COMMENT PARTITION:BY:TAKE:
18600 -ELE:AND:CLASS))
18700 OF THE FUNCTION ELEMENT:4 TO THIS NEW PIECE OF CODE,
18800 WHICH IS ITS BODY:
18900
19000 (ELEMENT:4
19100 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
19200 (STRUCTURE (OBJECTS SET O)
19300 (CLASS:NAME NAME N)
19400 (STATIC RELATIONS S BETWEEN OBJECTS))))
19500 (ELEMENT:4 redefined)
19600
19700 MOVE CURSOR TO ( HAS:NAME:5 TYPE OF ( IS:OF:TYPE))
19800
19900 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION
20000 DECISION: (HOW DO WE KNOW WHEN THE 'IS:OF:TYPE'
20100 PREDICATE IS TRUE, AND WHEN IT IS FALSE?
20200 PUP ASSUMES THAT USER WILL TYPE IN A
20300 LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT
20400 TO IT)
20500 SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
20600 TYPE IN THE DEFINITION OF HAS:NAME:5
20700
20800 SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
20900 LOGICAL EXPRESSION, WHICH IS TRUE IF ELEMENT:4 IS OF
21000 THE (PARTITION:BY:TAKE:ELE:AND:CLASS) TYPE,
21100 AND SHOULD BE FALSE IF IT ISNT
21200 OF THAT TYPE.
21300
21400 USER: \4(THE FRONT PART OF ARG1 ISNT ???)\*
21500
21600 (IS ??? A LITERAL CONSTANT (WHOSE VALUE SHOULD BE ITSELF) (REPLY YES OR
21700 NO, PLEASE) USER...)
21800 \4YES\*
21900
22000 DRAW A LINE FROM THE FUNCTION CALL (HAS:NAME:5 ELEMENT:4 (COMMENT PARTI
22100 -TION:BY:TAKE:ELE:AND:CLASS)) OF THE FUNCTION HAS:NAME:5 TO THIS NEW
22200 PIECE OF CODE, WHICH IS ITS BODY:
22300
22400 (HAS:NAME:5
22500 (LAMBDA (ARG1 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
22600 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
22700 (NOT (EQUAL (CAR ARG1)
22800 ???))))
22900
23000
23100 (HAS:NAME:5 redefined)
23200
23300 MOVE CURSOR TO ( TAKE:HOLD:OF:3 TYPE OF ( TAKE:HOLD:OF))
23400
23500 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
23600 ...HMMM...
23700
23800 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
23900 USER CHANNEL AFTER ALL!!!
24000
24100 (PUP IS ABOUT TO ENCODE AN ASSIGNMENT: (OBJECTS SET O) WILL BE SET TO
24200 SOME PART OF ARG1 WHICH IS GOING TO BE
24300 INSTANTIATED DURING THE RUNNING OF THE PROGRAM AS ELEMENT:4
24400 PUP WANTS A NAME FOR THIS 'SOME PART OF' FUNCTION.)
24500
24600 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:3 ELEMENT:4) OF THE
24700 FUNCTION TAKE:HOLD:OF:3 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
24800
24900 (TAKE:HOLD:OF:3
25000 (NLAMBDA (ARG1)
25100 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
25200 (PRINT (COMMENT READY TO ACCEPT BRAND NEW ELEMENT:4))
25300 (SET ARG1 (READ))
25400 (SETQ ELEMENT:OBJECTS:11 (SOME:PART:OF:12 (EVAL ARG1)))
25500 (SETQ ELEMENT:CLASSNAME:13 (SOME:PART:OF:14 (EVAL ARG1)))
25600 (SETQ ELEMENT:RELNS:15 (SOME:PART:OF:16 (EVAL ARG1)))
25700 T))
25800
25900 (COMMENT NAME:OF:CLASS IS NOT A BEING YET)
26000
26100 MOVE CURSOR TO ( TAKE:HOLD:OF:6 TYPE OF ( TAKE:HOLD:OF))
26200
26300 (THE ASSIGNMENT WHICH SET NAME:OF:CLASS
26400 WAS DONE EARLIER; SHOULD A NEW VALUE OF
26500 NAME:OF:CLASS BE READ IN AT THIS POINT IN
26600 THE PROGRAM FLOW? USER...)
26700 \4NO\*
26800
26900 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:6 NAME:OF:CLASS) OF THE
27000 FUNCTION TAKE:HOLD:OF:6 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
27100
27200 (TAKE:HOLD:OF:6
27300 (NLAMBDA (ARG1)
27400 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS)
27500 (COMMENT NOTHING MUCH TO DO HERE; JUST ONE SIMPLE ASSIGNMENT
27600 TO AN ALREADY EXISTING VALUE)
27700 (SET ARG1 OBVIOUS:KNOWN:VALUE:OF:NAME:OF:CLASS)))
27800
27900 MOVE CURSOR TO ( GET:HOLD:OF:8 TYPE OF ( GET:HOLD:OF))
28000
28100 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
28200 (COMPUTE SEARCH GENERATE:AND:TEST)
28300 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
28400 (A .... COMPUTE)
28500 (B .... SEARCH)
28600 (C .... GENERATE:AND:TEST)
28700
28800 USER: \4(B)\*
28900
29000
29100 YOU MUST GIVE ME A LIST OF ALL THE VALUES THAT COULD EVER OCCUR AS
29200 NAMES ON THE LIST STRUCTURE SET:OF:POSSIBLE:NAMES:OF:CLASS
29300
29400 IF THIS ISN'T MEANINGFUL, REPLY NIL.
29500
29600 USER: \4NIL\*
29700
29800 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
29900 (DOES AN ALGORITHM ALREADY EXIST WHICH GETS
30000 PRECISELY NAME:OF:CLASS)
30100 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
30200
30300 NOW TYPE YOUR ANSWER: \4NO\*
30400
30500 OK, READY TO MOVE ON NOW.
30600
30700 PUP IS NOW GOING TO ENCODE THE PIECE
30800 (PROGN (FOREACH POSSIBLE:NAME:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLASS
30900 DO (TEST POSSIBLE:NAME:OF:CLASS
31000 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
31100 (PRIN1 "
31200 MY GUESS FOR THIS IS ")
31300 (PRINT POSSIBLE:NAME:OF:CLASS))
31400
31500 OF THE FUNCTION GET:HOLD:OF:8 INTO LISP. FUNCTION NAMES WILL
31600 BE QUERIED IN PREORDER, AS NEEDED.
31700
31800 MOVE CURSOR TO ( FOREACH:17 TYPE OF ( FOREACH))
31900 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
32000 (I ASSUME THAT I STOP AFTER EXAMINING ALL
32100 POSSIBLE:NAMES:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLASS ;
32200 DO I ALSO STOP AFTER SOME CONDITION 'C' BECOMES TRUE?)
32300 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
32400
32500 NOW TYPE YOUR ANSWER: \4YES\*
32600
32700 PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
32800
32900 USER: \4(TEST:18 SUCCEEDED)\*
33000
33100 OK, READY TO MOVE ON NOW.
33200
33300 DRAW A LINE FROM THE FUNCTION CALL (FOREACH:17 POSSIBLE:NAME:OF:CLASS IN
33400 SET:OF:POSSIBLE:NAMES:OF:CLASS DO (TEST:18 POSSIBLE:NAME:OF:CLASS
33500 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
33600 OF THE FUNCTION FOREACH:17
33700 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
33800
33900 (FOREACH:17
34000 (NLAMBDA (ARG1 DUMMY:ARGUMENT:2 ARG3 DUMMY:ARGUMENT:1 ARG5)
34100 (COMMENT IN ALL CALLS TO DATE, ARG1 IS BOUND
34200 TO POSSIBLE:NAME:OF:CLASS)
34300 (COMMENT IN ALL CALLS TO DATE, ARG3 IS BOUND
34400 TO SET:OF:POSSIBLE:NAMES:OF:CLASS)
34500 (COMMENT IN ALL CALLS TO DATE, ARG5 IS BOUND
34600 TO (COMMENT TEST:18 POSSIBLE:NAME:OF:CLASS
34700 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
34800 (PROG (RESULT:1)
34900 (SETQ EVAL:ARG3 (EVAL ARG3))
35000 LABEL:2
35100 (COND
35200 ((NULL EVAL:ARG3)
35300 (SET ARG1 FAILURE:VALUE)
35400 (RETURN EXHAUSTION:VALUE)))
35500 (SET ARG1 (CAR EVAL:ARG3))
35600 (SETQ EVAL:ARG3 (CDR EVAL:ARG3))
35700 (SETQ RESULT:1 (EVAL ARG5))
35800 (COND
35900 ((NOT (EQUAL RESULT:1 NIL)) \5<This predicate is the
36000 translation of\* \4TEST:18 SUCCEEDED\*\5.>\*
36100 (RETURN UNTIL:CONDITION:VALUE))
36200 (T (GO LABEL:2)))
36300 (COMMENT AT THE TIME THAT FOREACH:17 WAS CODED, THE UNTIL
36400 CONDITION VALUE WAS LEFT UNDEFINED))))
36500
36600 MOVE CURSOR TO ( TEST:18 TYPE OF ( TEST))
36700
36800 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
36900 (SHOULD WE IMPLEMENT ERROR RECOVERY IN ANY
37000 FANCY WAY)
37100 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
37200
37300 \4NO\*
37400
37500 NOTHING TO DO AT THIS TIME, THEN.
37600
37700 OK, READY TO MOVE ON NOW.
37800
37900 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
38000 (( THE TESTING MAY HAVE THE CHARACTER
38100 OF COMPARING THE OBJECT WITH SOME DISTINGUISHED OBJECT)
38200 ( TESTING MAY HAVE THE CHARACTER OF LETTING THE OBJECT
38300 (WHICH IS ARG1) COMPETE WITH ITS FELLOW OBJECTS
38400 FOR SUPREMACY)
38500 ABOVE, ARG1 REFERS TO POSSIBLE:NAME:OF:CLASS )
38600
38700 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
38800 USER CHANNEL AFTER ALL!!!
38900
39000 PUP IS NOW GOING TO ENCODE THE PIECE
39100 (COMPARE ARG1 ELEMENT:4)
39200
39300
39400 OF THE FUNCTION TEST:18 INTO LISP. FUNCTION NAMES WILL
39500 BE QUERIED IN PREORDER, AS NEEDED.
39600
39700 DRAW A LINE FROM THE FUNCTION CALL (COMPARE:19 ARG1 ELEMENT:4) OF THE
39800 FUNCTION COMPARE:19 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
39900
40000 (COMPARE:19
40100 (LAMBDA (ARG1 ARG2)
40200 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS POSSIBLE:NAME:
40300 -OF:CLASS)
40400 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:4)
40500 ARG1
40600 ARG2
40700 (COMMENT ARG1 AND ARG2 ARE HERE SIMPLY TO CAUSE PUP
40800 TO STICK IN COMMENTS ABOUT THEIR INSTANTIATION)
40900 (JOIN:23 (COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20
41000 ELEMENT:OBJECTS:11)
41100 (COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21
41200 ELEMENT:CLASSNAME:13)
41300 (COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22
41400 ELEMENT:RELNS:15))))
41500
41600 .FILL
41700 \5Here begins one of the sections discussed on page 19 of this paper,
41800 the genesis of the MUSTNOT/MUST/MAY divisions. The names used
41900 here differ slightly from those in the body of the paper. The
42000 symbol # stands for "contradiction".\*
42100 .NOFILL
42200
42300 MOVE CURSOR TO ( JOIN:23 TYPE OF ( JOINING:FUNCTION))
42400
42500 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS PREDICATE DECISION:
42600 (WHEN WE TERMINATE THE LOOP)
42700
42800 PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ( WHEN WE TERMINATE
42900 THE LOOP) AND IS FALSE OTHERWISE.
43000
43100 USER: \4(ANY RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22 IS INCOMPATIBLE
43200 WITH ELEMENT:RELNS:15)\*
43300
43400 PUP IS NOW GOING TO ENCODE THE PIECE
43500 (AND ARG1 ARG2 ARG3) \5<The inference here, from the last user
43600 response. is that the joining function is AND.>\*
43700
43800 OF THE FUNCTION JOIN:23 INTO LISP. FUNCTION NAMES WILL
43900 BE QUERIED IN PREORDER, AS NEEDED.
44000
44100 DRAW A LINE FROM THE FUNCTION CALL OF THE FUNCTION JOIN:23 TO THIS NEW
44200 PIECE OF CODE, WHICH IS ITS BODY:
44300
44400 (JOIN:23
44500 (LAMBDA (ARG1 ARG2 ARG3)
44600 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
44700 COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20 ELEMENT:OBJECTS:11))
44800 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
44900 COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21 ELEMENT:CLASSNAME:13))
45000 (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
45100 COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22 ELEMENT:RELNS:15))
45200 (AND ARG1 ARG2 ARG3)))
45300
45400 (COMMENT POSSIBLE:NAME:OF:CLASS:OBJECTS:20 IS NOT A BEING YET)
45500 (COMMENT ELEMENT:OBJECTS:11 IS NOT A BEING YET)
45600
45700 MOVE CURSOR TO ( COMPARE:26 TYPE OF ( COMPARE))
45800 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
45900 (( COMPARING MAY INVOLVE A FUNCTION
46000 APPLIED DIRECTLY TO THE TWO ARGUMENTS)
46100 ( COMPARING MAY INVOLVE APPLYING A
46200 FUNCTION TO CORRESPONDING PAIRS OF
46300 SUBPARTS OF THE OBJECTS, AND FINALLY
46400 JOINING TOGETHER ALL THESE
46500 SUB-COMPARISONS' RESULTS)
46600 (ABOVE, ARG1 REFERS TO
46700 POSSIBLE:NAME:OF:CLASS:RELNS:22)
46800
46900 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
47000 USER CHANNEL AFTER ALL!!!
47100
47200 PUP IS NOW GOING TO ENCODE THE PIECE
47300 (PROGN (COMMENT HERE WE MAY LATER WANT TO PUT SOME ASSIGNMENTS,
47400 REWRITES, AND ITERATIVE STATEMENTS)
47500 (COND ((NOT (FORSOME RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22
47600 (RECOGNIZE:# RELATION ELEMENT:RELNS:15)))
47700 T)
47800 (T NIL)))
47900
48000 OF THE FUNCTION COMPARE:26 INTO LISP. FUNCTION NAMES WILL
48100 BE QUERIED IN PREORDER, AS NEEDED.
48200
48300 MOVE CURSOR TO ( CONTRADICTS:27 TYPE OF ( RECOGNIZE:#))
48400 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
48500 (PROBABILITY=1:#
48600 PROBABILITY=0:#
48700 PROBABILITY>0&<1:#)
48800 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
48900 (A .... PROBABILITY=1:#)
49000 (B .... PROBABILITY=0:#)
49100 (C .... PROBABILITY>0&<1:#)
49200
49300 USER: \4(A B C)\*
49400
49500
49600 (I RECOMMEND THAT POSSIBLE:NAME:OF:CLASS:RELNS:22 BE STRUCTURED INTO (AT
49700 LEAST ALONG ONE DIMENSION) THESE 3 PIECES:
49800 (PROBABILITY=1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22
49900 PROBABILITY=0:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22
50000 PROBABILITY>0&<1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22) .
50100 PLEASE TYPE BACK YES, NO, OR UNSURE.)
50200
50300 USER: \4YES\*
50400
50500
50600 \5 <The Long-Name-Demon now grumbles about these awkward names.>\*
50700
50800 I WANT A SHORTER NAME FOR
50900 PROBABILITY:1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS.
51000 PLEASE TYPE A BRAND NEW NAME IN TO ME.
51100
51200 USER: \4YES:RELNS\*
51300
51400 THE NAME CHOSEN IS YES:RELNS:28
51500
51600 .
51700 .
51800 .
51900
52000 DRAW A LINE FROM THE FUNCTION CALL
52100 (CONTRADICTS:27 RELATION ELEMENT:RELNS:15)
52200 OF THE FUNCTION CONTRADICTS:27 TO THIS NEW PIECE OF CODE, WHICH
52300 IS ITS BODY:
52400
52500 (CONTRADICTS:27
52600 (LAMBDA (ARG1 ARG2)
52700 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS RELATION)
52800 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:RELNS:15)
52900 (COND
53000 ((MEMBER ARG1 YES:RELNS:28)
53100 (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD
53200 BETTER BE IN ARG2, WHICH IS
53300 THE RELEVANT PIECE OF THE WORLD)
53400 (NOT (MEMBER ARG1 ARG2)))
53500 ((MEMBER ARG1 NO:RELNS:29)
53600 (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A
53700 CONTRADICTION IFF IT IS A
53800 MEMBER OF ARG2, WHICH IS
53900 THE RELEVANT PIECE OF THE WORLD)
54000 (MEMBER ARG1 ARG2))
54100 (T (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EITHER
54200 CASE IS ALLOWABLE; SO WE
54300 NEVER HAVE A CONTRADICTION)
54400 NIL))))
54500
54600 PUP: (PUP WORKED ON SOMETHING IMPROBABLE, NAMELY (IN ALL CODE GENERATED,
54700 POSSIBLE:NAME:OF:CLASS:RELNS:22 SHOULD BE
54800 REPLACED BY (APPEND YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)),
54900 AND HERE IS WHAT WE FINALLY DID ABOUT IT: (WE REPLACED
55000 ALL OCCURRENCES OF POSSIBLE:NAME:OF:CLASS:RELNS:22 BY
55100 (APPEND YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)))
55200
55300
55400 MOVE CURSOR TO ( MODIFY:STRUCTURE:7 TYPE OF ( MODIFY:STRUCTURE))
55500
55600 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SUBSETOF DECISION:
55700 (CONDITIONAL:INSERTION
55800 CONDITIONAL:DELETION
55900 COMPLEX:ALTERATION)
56000 SINCE THE DECISION IS SUBSET:OF, TYPE ANY ORDERED SUBSET OF:
56100 (A .... CONDITIONAL:INSERTION)
56200 (B .... CONDITIONAL:DELETION)
56300 (C .... COMPLEX:ALTERATION)
56400
56500 USER: \4(A C)\*
56600
56700 DRAW A LINE FROM THE FUNCTION CALL (MODIFY:STRUCTURE:7 NAME:OF:CLASS) OF
56800 THE FUNCTION MODIFY:STRUCTURE:7 TO THIS NEW PIECE OF CODE, WHICH IS
56900 ITS BODY:
57000
57100 (MODIFY:STRUCTURE:7
57200 (LAMBDA (ARG1)
57300 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS)
57400 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS NIL)
57500 (CONDITIONAL:INSERTION:31 ARG1 ARG2)
57600 (COMPLEX:ALTERATION:32 ARG1 ARG2)))
57700
57800 I HAVE DECIDED TO KEEP POSSIBLE:NAME:OF:CLASS STRUCTURED
57900 USING THE PROPERTY LIST FEATURE OF LISP.
58000 FOR THIS REASON, I NEED TO HAVE A NAME FOR EACH
58100 PROPERTY (CORRESPONDING TO EACH SUBPART OF POSSIBLE:NAME:OF:CLASS) :
58200
58300 \5<This is the end of the example fragments of dialogue>\*
00100 .FILL
00200
00300 \5Below is the same piece of dialogue set off by lines of asterisks on
00400 page A5.2. It occupied only seven lines of the preceding excerpt, but
00500 below it occupies eight pages. The user may interrupt after each BEING
00600 receives control, and often does. When in an interrupt,
00700 the user is prompted by\* REQUEST: \5, after which he may type in a
00800 query. This will typically be the name of a BEING part, which is then
00900 "asked" of the current BEING. The active BEINGs are kept on a stack,
01000 and typing CH will print out this stack. Typing OLDER or YOUNGER lets
01100 the user crawl around this stack; the question he types in is by default
01200 put to the BEING indicated by the stack marker (when printed, this BEING
01300 name is surrounded by asterisks). \*
01400
01500 .NOFILL
01600
01700 INTERRUPT? \4YES
01800 \*REQUEST: \4CH
01900 \*NIL *** CHOOSE:FROM *** (WRITE:PROGRAM SERVE)
02000 \5This last request, CH, asked PUP6 to type out the control history;
02100 who called who, etc. In the current case, this is simply a stack.
02200 The present BEING is CHOOSE:FROM, and it is delimited by asterisks.
02300 It was called by WRITE:PROGRAM which was called by SERVE.\*
02400
02500 REQUEST: \4WHAT
02600 \*(CHOOSE THE BEST BEING FROM THE SET (OBTAIN:USABLE:INFORMATION
02700 USE:INFORMATION
02800 FILL:IN:UNDEFINED:SECTION
02900 CLARIFY:IMPROBABLE:SITUATION
03000 ADAPT:PRECONCEIVED:FUNCTION
03100 FIX:INCORRECT:PIECE )
03200 OF BEINGS)
03300
03400 REQUEST: \4WHY
03500 \*(BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
03600
03700 REQUEST: \4OLDER
03800 \*WRITE:PROGRAM
03900
04000 REQUEST: \4CH
04100 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
04200
04300 REQUEST: \4WHAT
04400 \*(WRITE A PROGRAM WHICH DOES (CONCEPT:FORMATION))
04500 \5 <notice the effect of saying\* \4OLDER\* \5; questions are now
04600 directed to WRITE:PROGRAM instead of to CHOOSE:FROM.>\*
04700
04800 REQUEST: \4WHY
04900 \*(FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE
05000 WRITTEN TO DO (CONCEPT:FORMATION) IN ORDER THAT
05100 THE TASK (CONCEPT:FORMATION) MIGHT BE COMPLETED;
05200 ALSO, EXAMINE SPEC:WHY)
05300
05400 REQUEST: \4SPEC:WHY
05500 \*(WE CALL THE FIRST BEING WHICH CAN BRING ABOUT THE EFFECT
05600 (TYPE OF((CONCEPT:FORMATION) HAS BEEN STUDIED)))
05700
05800 REQUEST: \4HOW
05900 \*(CREATE SPECIALIZED LISP CODE WHICH WILL DO (CONCEPT:FORMATION))
06000
06100 REQUEST: \4?
06200 \*
06300 YOUR OPTIONS ARE AS FOLLOWS:
06400
06500 QUIT END THE INTERRUPT
06600 BEING PRINT NAME OF CURRENT BEING
06700 DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
06800 CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
06900 CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
07000 OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
07100 YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
07200 OLDEST CONSIDER THE FIRST BEING IN CONTROL
07300 YOUNGEST CONSIDER THE LAST BEING IN CONTROL
07400 SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
07500 FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
07600 NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
07700 SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
07800
07900 TYPING ONE OF THESE WILL PRINT OUT WRITE:PROGRAM'S ANSWER TO THAT
08000 QUESTION:
08100 (IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA
08200 NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS MINOR:EFFECTS WHEN
08300 META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS
08400 AFFECTS COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES
08500 PREDICATE DATA:STRUCTURE ENCODABLE INHIBIT:CURRENT:DEMONS FORM:CHANGING)
08600
08700 REQUEST: \4SPEC:WHEN
08800 \*((T IS T SO WE DO ADD IN THE WEIGHT (COND ((MEMBER TASK ABLE:PUP:LIST)
08900 -75) (T 40))
09000 WHICH IN THE CURRENT CASE IS 40;
09100 THE EXPLANATION IS (BECAUSE A PRE:EXISTING ABILITY TO DO
09200 (CONCEPT:FORMATION) IMPLIES THAT WRITING A NEW
09300 PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
09400 CONVERSELY, THE INABILITY TO
09500 DO ( CONCEPT:FORMATION) ABDUCTIVELY
09600 ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
09700 ((MEMBER TASK WRITTEN:PROGRAMS:LIST) IS NIL, SO WE DONT ADD IN THE
09800 WEIGHT -80 WHICH IN THE CURRENT CASE IS -80 ;
09900 THE EXPLANATION IS (BECAUSE WE ARE NOT MUCH AFTER EFFICIENCY, AND
10000 IF A PROGRAM ALREADY EXISTS, THEN WE SHOULD USE IT))
10100 ((MEMBER ( PUP IS ABOUT TO WRITE A PROGRAM TO DO (TASK)) AWARE:USER:LIST)
10200 IS NIL SO WE DONT ADD IN THE WEIGHT 70
10300 WHICH IN THE CURRENT CASE IS 70 ;
10400 THE EXPLANATION IS (BECAUSE WE GO BY THE OLD
10500 ENGLISH LEGAL RULE THAT SILENCE SIGNIFIES APPROVAL))
10600 (T IS T SO WE DO ADD IN THE WEIGHT (COND (NEW:INFO:LIST -120)
10700 (T 40)) WHICH IN THE CURRENT CASE IS 40 ;
10800 THE EXPLANATION IS (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE
10900 WRITING PROGRAMS .
11000 ALSO: BECAUSE IF NO NEW INFO IS PRESENT,
11100 THEN WE NEEDN'T FEEL GUILTY ABOUT STARTING TO WRITE
11200 A PROGRAM)))
11300 (THE FINAL WHEN VALUE IS THUS 80)
11400
11500 REQUEST: \4CH
11600 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
11700
11800 REQUEST: \4OLDER
11900 \*SERVE
12000
12100 REQUEST: \4CH
12200 \*(CHOOSE:FROM WRITE:PROGRAM) *** SERVE *** NIL
12300
12400 REQUEST: \4WHAT
12500 \*(DO ANYTHING THE USER ASKS)
12600
12700 REQUEST: \4WHY
12800 \*(FUNDAMENTAL DRIVE TO SERVE THE USER)
12900
13000 REQUEST: \4HOW
13100 \*(GET A TASK FROM THE USER)
13200
13300 REQUEST: \4QUIT
13400
13500 \*INTERRUPT? \4Y
13600 \*
13700 WRONG; TYPE YES OR NO ......... INTERRUPT? \4YES
13800
13900 \*REQUEST: \4BEING
14000 \*BETTER \5<i.e., the name of the BEING now in control is "BETTER">\*
14100
14200 REQUEST: \4WHAT
14300 \*(DECIDE WHICH OF (USE:INFORMATION (QUOTE PGM))
14400 (OBTAIN USABLE INFORMATION (QUOTE PGM))
14500 IS MORE A PROPOS TO TRY)
14600
14700 REQUEST: \4WHY
14800 \*(PUP CAN ONLY TRY AT MOST ONE OF USE:INFORMATION AND
14900 OBTAIN:USABLE:INFORMATION AT A TIME)
15000
15100 REQUEST: \4HOW
15200 \*(COMPARE THE WHEN PARTS OF USE:INFORMATION AND OBTAIN:USABLE:INFORMATION
15300 AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
15400
15500 REQUEST: \4COMPLEXITY:VECTOR
15600 \*(.5 .5 .5 .5 .1)
15700
15800 REQUEST: \4CH
15900 \*NIL *** BETTER *** (CHOOSE:FROM WRITE:PROGRAM SERVE)
16000
16100 REQUEST: \4QUIT
16200
16300 \*INTERRUPT? \4NO
16400 \*INTERRUPT? \4NO
16500 \*INTERRUPT? \4NO
16600 \*INTERRUPT? \4YES
16700
16800 \*REQUEST: \4WHAT
16900 \*(SATISFY THE SIMPLE SUBGOAL (TYPE OF ((CONCEPT:FORMATION) HAS BEEN
17000 STUDIED)))
17100
17200 REQUEST: \4HOW
17300 \*(PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
17400
17500 REQUEST: \4AFFECTS
17600 \*(((STUDY:TYPE (CONCEPT:FORMATION)) POSSIBLE:CALLED)
17700 (TRY:BEING CALLED)
17800 (SORT CALLED)
17900 (A:BEING:ORDER CALLED))
18000
18100 REQUEST: \4CH
18200 \*NIL *** SATISFY *** (FILL:IN:UNDEFINED:SECTION CHOOSE:FROM WRITE:PROGRAM
18300 SERVE)
18400
18500 REQUEST: \4OLDER
18600 \*FILL:IN:UNDEFINED:SECTION
18700
18800 REQUEST: \4WHAT
18900 \*(FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM PGM)
19000
19100 REQUEST: \4WHY
19200 \*(BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
19300
19400 REQUEST: \4HOW
19500 \*(CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
19600
19700 REQUEST: \4CHOICE
19800 \*( CF:1 TYPE OF ( CONCEPT:FORMATION))
19900
20000 REQUEST: \4QUIT
20100
20200 \*INTERRUPT? \4YES
20300
20400 \*REQUEST: \4BEING
20500 \*REINVESTIGATE:DECISION
20600
20700 REQUEST: \4WHAT
20800 \*(RESOLVE THE DECISION
20900 (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1)
21000 AFFECTS (WHETHER PARAMETERS
21100 DESCRIBING AN INDIVIDUAL MUST BE READ IN BY CF:1)
21200 WHEN (BEFORE ANY ROUTINES ARE FINALIZED)
21300 WHY (BECAUSE ANY PROCESSING
21400 ROUTINE MAY HAVE TO DEPEND UPON SOME INDIVIDUAL PARAMETERS))
21500 BECAUSE (SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
21600 IS NOW NONNULL; FIRST TRY TO DEFER IT A LITTLE LONGER)
21700
21800 REQUEST: \4HOW
21900 \*(TRY TO DEFER UNTIL ;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;
22000 ELSE ASK THE USER TO RESOLVE IT)
22100
22200 REQUEST: \4QUIT
22300
22400 \*INTERRUPT? \4YES
22500
22600 \*REQUEST: \4CH
22700 \*NIL *** DEFER:DECISION *** (REINVESTIGATE:DECISION FILL:IN:UNDEFINED:S-
22800 -ECTION CHOOSE:FROM WRITE:PROGRAM SERVE)
22900
23000 REQUEST: \4QUIT
23100
23200 \*INTERRUPT? \4YES
23300
23400 \*REQUEST: \4CH
23500 \*NIL *** UTILIZE *** (WHEN:NEXT DEFER:DECISION REINVESTIGATE:DECISION
23600 FILL:IN:UNDEFINED:SECTION CHOOSE:FROM
23700 WRITE:PROGRAM SERVE)
23800
23900 REQUEST: \4HOW
24000 \*(SEARCH THROUGH NIL FOR APPLICABLE RULES) \5<i.e., there are no known
24100 ways to defer this any longer>\*
24200
24300 REQUEST: \4QUIT
24400
24500 \*INTERRUPT? \4YES
24600
24700 \*REQUEST: \4CH
24800 \*NIL *** RESOLVE:DECISION *** (DEFER:DECISION REINVESTIGATE:DECISION
24900 FILL:IN:UNDEFINED:SECTION CHOOSE:FROM
25000 WRITE:PROGRAM SERVE)
25100
25200 REQUEST: \4WHY
25300 \*(AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION
25400 (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1) )
25500 CANNOT BE DEFERRED ANY LONGER)
25600
25700 REQUEST: \4HOW
25800 \*(TRY TO RESOLVE (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF
25900 CF:1)) WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK
26000 THE USER ABOUT IT)
26100
26200 REQUEST: \4QUIT
26300
26400 \*INTERRUPT? \4YES
26500
26600 \*REQUEST: \4CH
26700 \*NIL *** ASK:USER:ABOUT *** (RESOLVE:DECISION DEFER:DECISION REINVESTIG-
26800 -ATE:DECISION FILL:IN:UNDEFINED:SECTION
26900 CHOOSE:FROM WRITE:PROGRAM SERVE)
27000
27100 REQUEST: \4WHAT
27200 \*(ASK THE USER TO RESOLVE DECISION ((BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR
27300 MAY BE REQUIRED OF CF:1))
27400
27500 REQUEST: \4WHY
27600 \*(BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
27700
27800 REQUEST: \4QUIT
27900 \*
28000
28100 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
28200
28300 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
28400 (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
28500 OF CF:1)
28600 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
28700
28800 SHOULD I DISCUSS RAMIFICATIONS?\4NO\* \5 If the user answered
28900 affirmatively, copious amounts of data would appear, describing
29000 what this choice is, the effects of each possible answer, why it
29100 can't wait, who wanted this done, and so on. \*
29200
29300 NOW TYPE YOUR ANSWER: \4NO\*
29400
29500 OK, READY TO MOVE ON NOW.
29600
29700
29800 \5Here are a few more direct queries to BEINGS during the dialogue:\*
29900
30000 REQUEST: \4UNDEFINED:SECTION:LIST
30100 \*(( PARTITION:A:DOMAIN) ( PAD:2 TYPE OF ( PARTITION:A:DOMAIN)))
30200
30300 REQUEST: \4AWARE:USER:LIST
30400 \*(( THE NAME OF THE PROGRAM TO DO ( CONCEPT:FORMATION) IS CF:1)
30500 PUP: (PUP & USER MAY REFER TO THIS NEW
30600 SPECIALIZED VERSION OF (CONCEPT:FORMATION) AS CF:1)
30700
30800 REQUEST: \4(PLUS 2 2)\* \5 <The evaluation inside an interrupt is converse to DWIM:
30900 if the expression can be understood, it is processed specially;
31000 otherwise, we THEN try to EVAL the expression.>\*
31100 4
31200
31300 REQUEST: \4DEMONS
31400 \*THE CURRENT DEMONS ARE:
31500 (FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON PROGRAM:WRITING:DEMONS
31600 DEFERRAL:DEMON REINVESTIGATION:DEMON IDIOM:DEMON
31700 SPECIFICITY:CHECK:DEMON FORGETFUL:USER:DEMON)
31800 THE DEMON STACK IS ((PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATI-
31900 -ON:DEMON IDIOM:DEMON SPECIFICITY:CHECK:DEMON
32000 FORGETFUL:USER:DEMON)
32100 (FORGETFUL:USER:DEMON))
32200
32300 REQUEST: \4BEING:STACK
32400 \*(WRITE:PROGRAM SERVE)
32500
32600 REQUEST: \4NEW:LEVEL
32700 \*
32800 HELLO THERE. I AM READY TO SWITCH TO A DIFFERENT MODE OF INTERRUPTABILITY.
32900
33000 HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
33100 DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
33200
33300 0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
33400 2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
33500 4 DURING EACH PHASE OF WRITING A PROGRAM
33600 6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
33700 8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
33800 10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
33900
34000 OK, NOW TYPE A DIGIT... \4NO\*
34100
34200 *** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
34300 TRY AGAIN:
34400 \48\*
34500
34600 REQUEST: \4QUIT
34700 \*
34800
34900 .FILL
35000
35100 \5This concludes the "frequent-interrupt mode" excerpt. In the terminology
35200 of NEW:LEVEL, this was at interrupt level 10, while the earlier excerpts
35300 were at level 0. Recall that this last excerpt was but seven lines in the
35400 earlier excerpt, which in turn was only 3% of the actual 300-page dialogue.
35500 The reader who has read through to this point will probably agree that
35600 dialogue problems are central
35700 to automatic programming.\*